package com.example.springcloud.order.controller;

import com.example.springcloud.order.dto.OrderDTO;
import com.example.springcloud.order.entity.Order;
import com.example.springcloud.order.result.Result;
import com.example.springcloud.order.service.OrderService;
import com.example.springcloud.order.service.tcc.OrderTCCService;
import com.example.springcloud.order.service.saga.OrderSagaService;
import io.seata.spring.annotation.GlobalTransactional;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

/**
 * 订单控制器 - 演示 Seata 分布式事务各种模式
 *
 * 注意：Sentinel 限流演示已独立到 SentinelController
 */
@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderTCCService orderTCCService;

    @Autowired
    private OrderSagaService orderSagaService;

    /**
     * 创建订单 - AT 模式（默认）
     * 演示：Seata AT 模式分布式事务
     */
    @PostMapping("/create/at")
    public Result<Order> createOrderAT(@RequestBody OrderDTO orderDTO) {
        log.info("收到创建订单请求 - AT 模式: {}", orderDTO);
        // 不捕获异常，让 GlobalExceptionHandler 处理
        Order order = orderService.createOrderAT(orderDTO);
        return Result.success("订单创建成功 - AT 模式", order);
    }

    /**
     * 创建订单 - TCC 模式
     * 演示：Seata TCC 模式分布式事务
     */
    @PostMapping("/create/tcc")
    @GlobalTransactional(name = "create-order-tcc", rollbackFor = Exception.class)
    public Result<Order> createOrderTCC(@RequestBody OrderDTO orderDTO) {
        log.info("收到创建订单请求 - TCC 模式: {}", orderDTO);
        // 不捕获异常，让 GlobalExceptionHandler 处理
        Order order = orderTCCService.tryCreate(orderDTO);
        return Result.success("订单创建成功 - TCC 模式", order);
    }

    /**
     * 创建订单 - XA 模式
     * 演示：Seata XA 模式分布式事务
     */
    @PostMapping("/create/xa")
    public Result<Order> createOrderXA(@RequestBody OrderDTO orderDTO) {
        log.info("收到创建订单请求 - XA 模式: {}", orderDTO);
        // 不捕获异常，让 GlobalExceptionHandler 处理
        Order order = orderService.createOrderXA(orderDTO);
        return Result.success("订单创建成功 - XA 模式", order);
    }


    /**
     * 创建订单 - Saga 模式（状态机）
     * 演示：Seata Saga 模式分布式事务
     */
    @PostMapping("/create/saga")
    public Result<Order> createOrderSaga(@RequestBody OrderDTO orderDTO) {
        log.info("收到创建订单请求 - Saga 模式: {}", orderDTO);

        // 执行 Saga 状态机
        Order order = orderSagaService.executeSaga(
                orderDTO.getUserId(),
                orderDTO.getProductId(),
                orderDTO.getCount(),
                orderDTO.getMoney()
        );
        return Result.success("订单创建成功 - Saga 模式", order);
    }

    /**
     * 创建订单 - 回滚测试（SQL 成功执行后回滚）
     * 演示：undo_log 表的 Before Image 功能
     */
    @PostMapping("/create/rollback-test")
    public Result<Order> createOrderRollbackTest(@RequestBody OrderDTO orderDTO) {
        log.info("收到创建订单请求 - 回滚测试: {}", orderDTO);
        // 不捕获异常，让 GlobalExceptionHandler 处理
        Order order = orderService.createOrderRollbackTest(orderDTO);
        return Result.success("订单创建成功", order);
    }

    /**
     * 健康检查
     */
    @GetMapping("/health")
    public Result<String> health() {
        return Result.success("Order Service is running");
    }
}

